﻿using DBLibrary.DataBase;
using DevExpress.Data.XtraReports.Native;
using DevExpress.Mvvm;
using DevExpress.Xpf.Core;
using DevExpress.Xpo;
using DXApplications.Models;
using DXApplications.Services;
using System.Threading.Tasks;
using System.Net.Http;
using System.Net.Http.Json;
using System;
using System.Linq;
using System.Security.Policy;
using Windows.Web.AtomPub;

namespace DXApplications.ViewModels
{
    public class TyprManageViewModel : ViewModelBase
    {
        public ObservableRangeCollection<TypesModel> FileTypes { get; set; }
        private readonly ApiService _apiService;

        public TyprManageViewModel()
        {
            _apiService = new ApiService();
            // 初始化文件类型
            InitializeFileTypes();
        }

        private async void InitializeFileTypes()
        {
            try
            {
                FileTypes = new ObservableRangeCollection<TypesModel>();
                var types = await _apiService.GetFileTypesAsync();
                FileTypes.AddRange(types);
            }
            catch (Exception ex)
            {
                // 如果API调用失败，可以回退到本地数据库访问作为备用方案
                try
                {
                    FileTypes = new ObservableRangeCollection<TypesModel>();
                    var uow = new UnitOfWork();
                    var types = uow.Query<FileType>().ToList();
                    foreach (var type in types)
                    {
                        FileTypes.Add(new TypesModel
                        {
                            FileTypeID = Convert.ToInt32(type.Id),
                            FileTypeName = type.TypeName,
                            MemoryStrength = type.MemoryStrength
                        });
                    }
                }
                catch
                {
                    // 如果回退方案也失败，只显示空的文件类型列表
                    FileTypes = new ObservableRangeCollection<TypesModel>();
                }
            }
        }
        public async Task RefreshFileTypes()
        {
            try
            {
                var types = await _apiService.GetFileTypesAsync();
                FileTypes.Clear();
                FileTypes.AddRange(types);
            }
            catch (Exception ex)
            {
                MessageBoxServiceExtensions.ShowMessage(
                    this.GetService<DXMessageBoxService>(),
                    $"刷新类型列表时发生错误: {ex.Message}",
                    "错误",
                    MessageButton.OK,
                    MessageIcon.Error);
            }
        }

        public async Task UpdateFileTypes()
        {
            try
            {
                FileTypes.Clear();
                var types = await _apiService.GetFileTypesAsync();
                FileTypes.AddRange(types);
            }
            catch (Exception ex)
            {
                // 如果API调用失败，可以回退到本地数据库访问作为备用方案
                try
                {
                    FileTypes.Clear();
                    var uow = new UnitOfWork();
                    var types = uow.Query<FileType>().ToList();
                    foreach (var type in types)
                    {
                        FileTypes.Add(new TypesModel
                        {
                            FileTypeID = Convert.ToInt32(type.Id),
                            FileTypeName = type.TypeName,
                            MemoryStrength = type.MemoryStrength
                        });
                    }
                }
                catch (Exception innerEx)
                {
                    MessageBoxServiceExtensions.ShowMessage(
                        this.GetService<DXMessageBoxService>(),
                        $"更新类型列表时发生错误: {innerEx.Message}",
                        "错误",
                        MessageButton.OK,
                        MessageIcon.Error);
                }
            }
        }

        public async Task DeleteFileType(TypesModel type)
        {
            if (type == null) throw new ArgumentNullException(nameof(type), "类型不能为空");
            
            try
            {
                // 使用API服务删除文件类型
                var result = await _apiService.DeleteFileTypeAsync(type.FileTypeID);
                
                if (result)
                {
                    // 从本地集合中删除
                    FileTypes.Remove(type);
                    
                    MessageBoxServiceExtensions.ShowMessage(
                        this.GetService<DXMessageBoxService>(),
                        $"类型 '{type.FileTypeName}' 已成功删除",
                        "成功",
                        MessageButton.OK,
                        MessageIcon.Information);
                }
                else
                {
                    // 显示错误消息
                    MessageBoxServiceExtensions.ShowMessage(
                        this.GetService<DXMessageBoxService>(),
                        $"删除类型 '{type.FileTypeName}' 失败",
                        "错误",
                        MessageButton.OK,
                        MessageIcon.Error);
                }
            }
            catch (Exception ex)
            {
                // 捕获异常并显示错误消息
                MessageBoxServiceExtensions.ShowMessage(
                    this.GetService<DXMessageBoxService>(),
                    $"删除类型时发生错误: {ex.Message}",
                    "错误",
                    MessageButton.OK,
                    MessageIcon.Error);
            }
        }

        public async Task AddOrUpdate(TypesModel type)
        {
            if (type == null) throw new ArgumentNullException(nameof(type), "类型不能为空");
            if (!IsFileTypeValid(type)) return; // 验证类型是否有效
            
            // 对于新增的文件类型，FileTypeID通常为0
            if (type.FileTypeID > 0)
            {
                await updateFileType(type);
            }
            else
            {
                await AddFileType(type);
            }
        }
        public async Task updateFileType(TypesModel type)
        {
            if (type == null) throw new ArgumentNullException(nameof(type), "类型不能为空");
            
            try
            {
                // 注意：这里我们假设后端API有更新文件类型的端点
                // 如果实际API没有这个端点，可能需要添加或者使用其他方式
                var request = new { TypeName = type.FileTypeName, MemoryStrength = type.MemoryStrength };
                var httpClient = new HttpClient { BaseAddress = new Uri("http://localhost:5269/api/") };
                var response = await httpClient.PutAsJsonAsync($"file/types/{type.FileTypeID}", request);
                
                if (response.IsSuccessStatusCode)
                {
                    // 更新集合中的类型
                    var index = FileTypes.IndexOf(type);
                    if (index >= 0)
                    {
                        FileTypes[index] = type;
                    }
                }
                else
                {
                    MessageBoxServiceExtensions.ShowMessage(
                        this.GetService<DXMessageBoxService>(),
                        $"更新类型时发生错误: HTTP {(int)response.StatusCode}",
                        "错误",
                        MessageButton.OK,
                        MessageIcon.Error);
                }
            }
            catch (Exception ex)
            {
                MessageBoxServiceExtensions.ShowMessage(
                    this.GetService<DXMessageBoxService>(),
                    $"更新类型时发生错误: {ex.Message}",
                    "错误",
                    MessageButton.OK,
                    MessageIcon.Error);
            }
        }
        public bool IsFileTypeValid(TypesModel type)
        {
            if (type == null)
            {
                throw new ArgumentNullException(nameof(type), "类型不能为空");
            }
            
            if (string.IsNullOrWhiteSpace(type.FileTypeName)) 
            {
                return false;
            }
            
            if (type.MemoryStrength <= 0) 
            {
                throw new InvalidOperationException($"记忆强度 '{type.MemoryStrength}' 必须大于0");
            }

            // 注意：由于我们现在使用API调用，可以选择在API层进行重复名称检查，
            // 或者实现一个异步版本的IsFileTypeValid方法来调用API检查重复

            return true;
        }
        public async Task AddFileType(TypesModel type)
        {
            try
            {
                // 使用ApiService调用后端API添加文件类型
                bool success = await _apiService.AddFileTypeAsync(type);
                
                if (success)
                {
                    // 添加成功后刷新文件类型列表
                    await RefreshFileTypes();
                    
                    MessageBoxServiceExtensions.ShowMessage(
                        this.GetService<DXMessageBoxService>(),
                        $"类型 '{type.FileTypeName}' 添加成功！",
                        "成功",
                        MessageButton.OK,
                        MessageIcon.Information);
                }
                else
                {
                    MessageBoxServiceExtensions.ShowMessage(
                        this.GetService<DXMessageBoxService>(),
                        $"添加类型 '{type.FileTypeName}' 失败！",
                        "错误",
                        MessageButton.OK,
                        MessageIcon.Error);
                }
            }
            catch (Exception ex)
            {
                MessageBoxServiceExtensions.ShowMessage(
                    this.GetService<DXMessageBoxService>(),
                    $"添加类型时发生错误: {ex.Message}",
                    "错误",
                    MessageButton.OK,
                    MessageIcon.Error);
            }
        }

    }
}
